home *** CD-ROM | disk | FTP | other *** search
/ PC go! 2018 July / PCgo 07-2018 CD-ROM Germany.iso / nw.pak / Unnamed File 004912.txt < prev    next >
Encoding:
Text File  |  2015-07-29  |  5.7 KB  |  175 lines
  1. // Copyright 2014 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4.  
  5. var createClassWrapper = requireNative('utils').createClassWrapper;
  6. var nativeDeepCopy = requireNative('utils').deepCopy;
  7. var schemaRegistry = requireNative('schema_registry');
  8. var CHECK = requireNative('logging').CHECK;
  9. var DCHECK = requireNative('logging').DCHECK;
  10. var WARNING = requireNative('logging').WARNING;
  11.  
  12. /**
  13.  * An object forEach. Calls |f| with each (key, value) pair of |obj|, using
  14.  * |self| as the target.
  15.  * @param {Object} obj The object to iterate over.
  16.  * @param {function} f The function to call in each iteration.
  17.  * @param {Object} self The object to use as |this| in each function call.
  18.  */
  19. function forEach(obj, f, self) {
  20.   for (var key in obj) {
  21.     if ($Object.hasOwnProperty(obj, key))
  22.       $Function.call(f, self, key, obj[key]);
  23.   }
  24. }
  25.  
  26. /**
  27.  * Assuming |array_of_dictionaries| is structured like this:
  28.  * [{id: 1, ... }, {id: 2, ...}, ...], you can use
  29.  * lookup(array_of_dictionaries, 'id', 2) to get the dictionary with id == 2.
  30.  * @param {Array.<Object.<string, ?>>} array_of_dictionaries
  31.  * @param {string} field
  32.  * @param {?} value
  33.  */
  34. function lookup(array_of_dictionaries, field, value) {
  35.   var filter = function (dict) {return dict[field] == value;};
  36.   var matches = array_of_dictionaries.filter(filter);
  37.   if (matches.length == 0) {
  38.     return undefined;
  39.   } else if (matches.length == 1) {
  40.     return matches[0]
  41.   } else {
  42.     throw new Error("Failed lookup of field '" + field + "' with value '" +
  43.                     value + "'");
  44.   }
  45. }
  46.  
  47. function loadTypeSchema(typeName, defaultSchema) {
  48.   var parts = $String.split(typeName, '.');
  49.   if (parts.length == 1) {
  50.     if (defaultSchema == null) {
  51.       WARNING('Trying to reference "' + typeName + '" ' +
  52.               'with neither namespace nor default schema.');
  53.       return null;
  54.     }
  55.     var types = defaultSchema.types;
  56.   } else {
  57.     var schemaName = $Array.join($Array.slice(parts, 0, parts.length - 1), '.');
  58.     var types = schemaRegistry.GetSchema(schemaName).types;
  59.   }
  60.   for (var i = 0; i < types.length; ++i) {
  61.     if (types[i].id == typeName)
  62.       return types[i];
  63.   }
  64.   return null;
  65. }
  66.  
  67. /**
  68.  * Takes a private class implementation |cls| and exposes a subset of its
  69.  * methods |functions| and properties |properties| and |readonly| in a public
  70.  * wrapper class that it returns. Within bindings code, you can access the
  71.  * implementation from an instance of the wrapper class using
  72.  * privates(instance).impl, and from the implementation class you can access
  73.  * the wrapper using this.wrapper (or implInstance.wrapper if you have another
  74.  * instance of the implementation class).
  75.  * @param {string} name The name of the exposed wrapper class.
  76.  * @param {Object} cls The class implementation.
  77.  * @param {{superclass: ?Function,
  78.  *          functions: ?Array.<string>,
  79.  *          properties: ?Array.<string>,
  80.  *          readonly: ?Array.<string>}} exposed The names of properties on the
  81.  *     implementation class to be exposed. |superclass| represents the
  82.  *     constructor of the class to be used as the superclass of the exposed
  83.  *     class; |functions| represents the names of functions which should be
  84.  *     delegated to the implementation; |properties| are gettable/settable
  85.  *     properties and |readonly| are read-only properties.
  86.  */
  87. function expose(name, cls, exposed) {
  88.   var publicClass = createClassWrapper(name, cls, exposed.superclass);
  89.  
  90.   if ('functions' in exposed) {
  91.     $Array.forEach(exposed.functions, function(func) {
  92.       publicClass.prototype[func] = function() {
  93.         var impl = privates(this).impl;
  94.         return $Function.apply(impl[func], impl, arguments);
  95.       };
  96.     });
  97.   }
  98.  
  99.   if ('properties' in exposed) {
  100.     $Array.forEach(exposed.properties, function(prop) {
  101.       $Object.defineProperty(publicClass.prototype, prop, {
  102.         enumerable: true,
  103.         get: function() {
  104.           return privates(this).impl[prop];
  105.         },
  106.         set: function(value) {
  107.           var impl = privates(this).impl;
  108.           delete impl[prop];
  109.           impl[prop] = value;
  110.         }
  111.       });
  112.     });
  113.   }
  114.  
  115.   if ('readonly' in exposed) {
  116.     $Array.forEach(exposed.readonly, function(readonly) {
  117.       $Object.defineProperty(publicClass.prototype, readonly, {
  118.         enumerable: true,
  119.         get: function() {
  120.           return privates(this).impl[readonly];
  121.         },
  122.       });
  123.     });
  124.   }
  125.  
  126.   return publicClass;
  127. }
  128.  
  129. /**
  130.  * Returns a deep copy of |value|. The copy will have no references to nested
  131.  * values of |value|.
  132.  */
  133. function deepCopy(value) {
  134.   return nativeDeepCopy(value);
  135. }
  136.  
  137. /**
  138.  * Wrap an asynchronous API call to a function |func| in a promise. The
  139.  * remaining arguments will be passed to |func|. Returns a promise that will be
  140.  * resolved to the result passed to the callback or rejected if an error occurs
  141.  * (if chrome.runtime.lastError is set). If there are multiple results, the
  142.  * promise will be resolved with an array containing those results.
  143.  *
  144.  * For example,
  145.  * promise(chrome.storage.get, 'a').then(function(result) {
  146.  *   // Use result.
  147.  * }).catch(function(error) {
  148.  *   // Report error.message.
  149.  * });
  150.  */
  151. function promise(func) {
  152.   var args = $Array.slice(arguments, 1);
  153.   DCHECK(typeof func == 'function');
  154.   return new Promise(function(resolve, reject) {
  155.     args.push(function() {
  156.       if (chrome.runtime.lastError) {
  157.         reject(new Error(chrome.runtime.lastError));
  158.         return;
  159.       }
  160.       if (arguments.length <= 1)
  161.         resolve(arguments[0]);
  162.       else
  163.         resolve($Array.slice(arguments));
  164.     });
  165.     $Function.apply(func, null, args);
  166.   });
  167. }
  168.  
  169. exports.forEach = forEach;
  170. exports.loadTypeSchema = loadTypeSchema;
  171. exports.lookup = lookup;
  172. exports.expose = expose;
  173. exports.deepCopy = deepCopy;
  174. exports.promise = promise;
  175.